
var express = require('express');
var router = express.Router();
var nodemailer = require('nodemailer');

var bcrypt  = require("bcrypt")


const axios = require('axios');
const { conversation,Counter,registerModel } = require('../model/db');
const FormData = require('form-data');
const fs = require('fs');
const { v4: uuidv4 } = require('uuid');
const rateLimit = require('express-rate-limit');
const crypto = require('crypto'); // 添加在文件顶部
const path = require('path'); // 确保已引入
const XF_API_URL = 'http://raasr.xfyun.cn/api'; // 添加到配置部分
const os = require('os');



// 设置bcrypt的盐轮数
const saltRounds = 10;


// 李键良

/* ============== 邮箱验证码相关功能 ============== */
// 使用环境变量或默认值
const EMAIL_USER = process.env.EMAIL_USER || '2818975440@qq.com'; // 发件人邮箱
const EMAIL_PASS = process.env.EMAIL_PASS || 'gdpeqxdxhjqtdcee'; // 邮箱授权码

// 创建邮件传输器
const transporter = nodemailer.createTransport({
  host: 'smtp.qq.com',
  port: 465,
  secure: true,
  auth: {
    user: EMAIL_USER,
    pass: EMAIL_PASS
  },
  // 增加超时设置
  connectionTimeout: 10000, // 连接超时时间
  greetingTimeout: 5000,    // 问候超时时间
  socketTimeout: 10000,     // 套接字超时时间
  debug: false,             // 生产环境关闭调试
  logger: false             // 生产环境关闭日志
});

// 验证邮件传输器配置
transporter.verify(function(error, success) {
  if (error) {
    console.error('邮件传输器验证失败:', error);
  } else {
    console.log('邮件服务器连接成功，可以发送邮件');
  }
});

const verificationCodes = new Map();
const resetTokens = new Map();

// 发送邮箱验证码接口
router.post('/send-register-code', async (req, res) => {
  try {
    // 从请求体获取邮箱
    const { email } = req.body;
    
    // 验证邮箱格式
    if (!email || !/^\S+@\S+\.\S+$/.test(email)) {
      return res.status(400).json({ code: 400, message: '邮箱格式不正确' });
    }

    // 检查邮箱是否已注册 - 使用 Promise 和超时处理
    try {
      const existingUser = await Promise.race([
        registerModel.findOne({ email }).exec(),
        new Promise((_, reject) => 
          setTimeout(() => reject(new Error('数据库查询超时')), 5000)
        )
      ]);
      
      if (existingUser) {
        return res.status(400).json({ code: 400, message: '该邮箱已注册' });
      }
    } catch (dbError) {
      console.error('数据库查询错误:', dbError);
      // 数据库错误时继续处理，不阻止验证码发送
    }

    // 随机验证码
    const code = Math.floor(100000 + Math.random() * 900000);
    // 设置验证码有效期
    const expiresAt = Date.now() + 5 * 60 * 1000;
    // 存储验证码及其有效期
    verificationCodes.set(email, { code, expiresAt });

    // 发送验证码邮件
    const info = await transporter.sendMail({
      from: `"AI心理健系统" <${EMAIL_USER}>`,
      to: email,
      subject: '注册验证码',
      html: `
        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px; border: 1px solid #eee; border-radius: 8px;">
          <h2 style="color: #1890ff; text-align: center;">AI心理健</h2>
          <p style="text-align: center; font-size: 16px; margin: 20px 0;">您的注册验证码是：</p>
          <h3 style="color: #333; text-align: center; margin: 10px 0; font-size: 24px;">${code}</h3>
          <p style="text-align: center; color: #666; margin-top: 20px;">有效期5分钟，请勿泄露给他人</p>
        </div>
      `
    });

    console.log('邮件已发送:', info.messageId);
    res.json({ code: 200, message: '验证码已发送' });

  } catch (error) {
    console.error('邮件发送失败详情:', {
      error: error.message,
      stack: error.stack
    });

    // 格式化错误信息
    let errorMessage = '发送验证码失败';
    if (error.message.includes('Invalid login')) {
      errorMessage = '邮箱账号或授权码错误，请检查SMTP配置';
    } else if (error.message.includes('Connection timeout') || error.message.includes('timed out')) {
      errorMessage = '连接SMTP服务器超时，请检查网络连接';
    } else if (error.message.includes('550')) {
      errorMessage = '邮箱服务拒绝发送，请检查邮箱设置';
    }

    res.status(500).json({
      code: 500,
      message: errorMessage
    });
  }
});

// 发送邮箱验证码接口
router.post('/send-login-code', async (req, res) => {
  try {
    // 从请求体获取邮箱
    const { email } = req.body;
    // 验证邮箱格式
    if (!email || !/^\S+@\S+\.\S+$/.test(email)) {
      return res.status(400).json({ code: 400, message: '邮箱格式不正确' });
    }
    // 随机验证码
    const code = Math.floor(100000 + Math.random() * 900000);
    // 设置验证码有效期
    const expiresAt = Date.now() + 5 * 60 * 1000;
    // 存储验证码及其有效期
    verificationCodes.set(email, { code, expiresAt });

    // 发送验证码邮件
    const info = await transporter.sendMail({
      from: `"系统管理员" <${EMAIL_USER}>`,
      to: email,
      subject: '登录验证码',
      html: `
        <div style="font-family: Arial, sans-serif; max-width: 600px; margin: 0 auto; padding: 20px; border: 1px solid #eee; border-radius: 8px;">
          <h2 style="color: #1890ff; text-align: center;">爱韵动</h2>
          <p style="text-align: center; font-size: 16px; margin: 20px 0;">您的登录验证码是：</p>
          <h3 style="color: #333; text-align: center; margin: 10px 0; font-size: 24px;">${code}</h3>
          <p style="text-align: center; color: #666; margin-top: 20px;">有效期5分钟，请勿泄露给他人</p>
        </div>
      `
    });

    console.log('邮件已发送:', info.messageId);
    res.json({ code: 200, message: '验证码已发送' });

  } catch (error) {
    console.error('邮件发送失败详情:', {
      error: error.message,
      stack: error.stack,
      config: {
        EMAIL_USER: EMAIL_USER,
        EMAIL_PASS: EMAIL_PASS ? '******' : '未设置'
      }
    });

    // 格式化错误信息
    let errorMessage = '发送验证码失败';
    if (error.message.includes('Invalid login')) {
      errorMessage = '邮箱账号或授权码错误，请检查SMTP配置';
    } else if (error.message.includes('Connection timeout')) {
      errorMessage = '连接SMTP服务器超时，请检查网络连接';
    } else if (error.message.includes('550')) {
      errorMessage = '邮箱服务拒绝发送，请检查邮箱设置';
    }

    res.status(500).json({
      code: 500,
      message: errorMessage,
      detail: process.env.NODE_ENV === 'development' ? error.message : '服务器内部错误'
    });
  }
});

//  验证邮箱验证码接口
router.post('/verify-code', (req, res) => {
  try {
    // 从请求体获取邮箱和验证码
    const { email, code } = req.body;
    console.log('收到验证请求:', { email, code });

    // 验证参数完整性
    if (!email || !code) {
      console.log('验证失败: 参数不完整', { email, code });
      return res.status(400).json({ code: 400, message: '参数不完整' });
    }

    // 获取存储的验证码记录
    const record = verificationCodes.get(email);
    console.log('验证码记录:', record);

    // 验证验证码是否存在
    if (!record) {
      console.log('验证失败: 未找到验证码记录', { email });
      return res.status(400).json({ code: 400, message: '请先获取验证码' });
    }

    // 验证验证码是否过期
    if (record.expiresAt < Date.now()) {
      console.log('验证失败: 验证码过期', { email, expiresAt: record.expiresAt });
      verificationCodes.delete(email); // 移除过期验证码
      return res.status(400).json({ code: 400, message: '验证码已过期' });
    }

    // 验证验证码是否正确
    if (parseInt(code) !== record.code) {
      console.log('验证失败: 验证码不匹配', { provided: parseInt(code), expected: record.code });
      return res.status(400).json({ code: 400, message: '验证码错误' });
    }

    // 生成临时登录令牌
    const token = crypto.randomBytes(32).toString('hex');
    // 存储令牌并关联邮箱
    resetTokens.set(token, email);
    // 移除已验证的验证码
    verificationCodes.delete(email);

    res.json({ code: 200, message: '验证成功', data: { token } });

  } catch (error) {
    console.error('验证码验证错误:', error);
    res.status(500).json({ code: 500, message: '服务器错误' });
  }
});

// 用户注册接口
router.post('/register', async (req, res) => {
  try {
    const { email, password, code } = req.body;

    // 验证参数完整性
    if (!email || !password || !code) {
      return res.status(400).json({ code: 400, message: '参数不完整' });
    }

    // 验证邮箱格式
    if (!/^\S+@\S+\.\S+$/.test(email)) {
      return res.status(400).json({ code: 400, message: '邮箱格式不正确' });
    }

    // 获取存储的验证码记录
    const record = verificationCodes.get(email);

    // 验证验证码是否存在
    if (!record) {
      return res.status(400).json({ code: 400, message: '请先获取验证码' });
    }

    // 验证验证码是否过期
    if (record.expiresAt < Date.now()) {
      verificationCodes.delete(email); // 移除过期验证码
      return res.status(400).json({ code: 400, message: '验证码已过期' });
    }

    // 验证验证码是否正确
    if (parseInt(code) !== record.code) {
      return res.status(400).json({ code: 400, message: '验证码错误' });
    }

    try {
      // 检查邮箱是否已注册 - 使用 Promise 和超时处理
      // const existingUser = await Promise.race([
      //   registerModel.findOne({ email }).exec(),
      //   new Promise((_, reject) => 
      //     setTimeout(() => reject(new Error('数据库查询超时')), 5000)
      //   )
      // ]);

      const existingUser = await registerModel.findOne({email})
      console.log(existingUser);
      
      
      if (existingUser) {
        return res.status(400).json({ code: 400, message: '该邮箱已注册' });
      }

      console.log('注册密码处理:', { 
        receivedPasswordLength: password.length,
        receivedPasswordType: typeof password,
        receivedPasswordPrefix: password.substring(0, 10) + '...'
      });
      
      // const salt = await bcrypt.genSalt(saltRounds);
      const dbHash = await bcrypt.hash(password, saltRounds);
      
      console.log('密码哈希完成:', { 
        saltRounds, 
        hashedPasswordLength: dbHash.length,
        hashedPasswordPrefix: dbHash.substring(0, 10) + '...'
      });

      
      // 创建新用户
      const newUser = new registerModel({
        email,
        password:dbHash,
        createdAt: new Date()
      });

      await newUser.save();
      
      // 移除已验证的验证码
      verificationCodes.delete(email);

      res.json({ code: 200, message: '注册成功' });
    } catch (dbError) {
      console.error('数据库操作错误:', dbError);
      res.status(500).json({ code: 500, message: '数据库操作失败，请稍后重试' });
    }

  } catch (error) {
    console.error('注册错误:', error);
    res.status(500).json({ code: 500, message: '服务器错误' });
  }
});


router.post('/login', async (req, res) => {
  try {
      const { email, password } = req.body;

      // 验证参数完整性
      if (!email || !password) {
          return res.status(400).json({ code: 400, message: '邮箱和密码不能为空' });
      }

      // 验证邮箱格式
      if (!/^\S+@\S+\.\S+$/.test(email)) {
          return res.status(400).json({ code: 400, message: '邮箱格式不正确' });
      }

      console.log('登录请求:', { 
        email, 
        passwordLength: password.length,
        passwordType: typeof password,
        passwordPrefix: password.substring(0, 10) + '...' // 显示密码前10个字符
      });
      
      // 根据邮箱查找用户
      const user = await registerModel.findOne({ email });
      if (!user) {
          console.log('用户不存在:', email);
          return res.status(400).json({ code: 400, message: '邮箱还未注册' });
      }
      
      console.log('找到用户:', { 
        userId: user._id, 
        email: user.email,
        storedPasswordLength: user.password.length,
        storedPasswordPrefix: user.password.substring(0, 10) + '...'
      });



      
      // 使用bcrypt比较密码哈希值
      const isMatch = await bcrypt.compare(password, user.password);
      console.log('密码验证结果:', isMatch);

      if (!isMatch) {
          console.log('密码验证失败:', email);
          return res.status(400).json({ code: 400, message: '邮箱或密码不正确' });
      }
      
      // 登录成功
      console.log('登录成功:', { userId: user._id, email: user.email });
      res.json({ 
          code: 200, 
          message: '登录成功', 
          userId: user._id,
          email: user.email,
          createdAt: user.createdAt
      });
  } catch (error) {
      console.error('登录失败:', error);
      res.status(500).json({ code: 500, message: '服务器错误，登录失败' });
  }
});


// 建议通过环境变量配置API密钥
const DEEPSEEK_API_KEY = process.env.DEEPSEEK_API_KEY || 'sk-bwdzawqhijfsvwuhtebgzvzcyfejxdradkbzdzdewziizkgc';

router.post('/chat', async (req, res) => {
  const { message } = req.body;
  
  // 参数验证
  if (!message || typeof message !== 'string') {
    return res.status(400).json({ error: 'Invalid message format' });
  }

  try {
    const response = await axios.post(
      'https://api.siliconflow.cn/v1/chat/completions',
      {
        model: 'Qwen/Qwen2.5-VL-72B-Instruct', // 使用正确的模型名称
        messages: [{
          role: 'user',
          content: message.substring(0, 2000) // 限制输入长度
        }],
        temperature: 0.7,
        max_tokens: 1000,
        stream: false // 关闭流式响应
      },
      {
        headers: {
          'Authorization': `Bearer ${DEEPSEEK_API_KEY}`,
          'Content-Type': 'application/json',
          'Accept': 'application/json'
        },
        timeout: 30000 // 10秒超时
      }
    );

    // 处理API响应
    const reply = response.data.choices[0]?.message?.content || 'No response';
    res.json({ reply });

  } catch (error) {
    console.error('DeepSeek API Error:', error.response?.data || error.message);
    
    // 增强错误处理
    const status = error.response?.status || 500;
    let errorMessage = 'AI服务异常';
    
    if (status === 402) {
      errorMessage = '账户配额不足，请检查API密钥或充值';
    } else if (status === 429) {
      errorMessage = '请求过于频繁，请稍后再试';
    }

    res.status(status).json({ 
      error: errorMessage,
      detail: error.response?.data?.error || error.message 
    });
  }
});

// 创建新对话
// let conversationCount = 0; // 全局变量记录对话总数
router.post('/conversations', async (req, res) => {
  try {
    const {
      title,
      model,
      checkpoints,
      preferredName,
      icon,
      communicationStyle,
      therapyGoal,
      isPublic
    } = req.body;

    // 验证必填字段
    if (!title || !model) {
      return res.status(400).json({ error: '标题和模型是必填项' });
    }

    // 创建新对话
    const newConversation = new conversation({
      title,
      model,
      checkpoints: checkpoints || [],
      preferredName: preferredName || 'User',
      icon: icon || 'default',
      communicationStyle: communicationStyle || 'formal',
      therapyGoal: therapyGoal || '降低压力水平',
      isPublic: isPublic !== undefined ? isPublic : false,
      createdAt: new Date()
    });

    // 保存到数据库
    await newConversation.save();

    // 原子性增加计数器
    const counter = await Counter.findOneAndUpdate(
      { name: 'conversation' },
      { $inc: { count: 1 } },
      { new: true, upsert: true }
    );

    res.status(201).json({
      success: true,
      count: counter.count,
      conversationId: newConversation._id, // 返回对话ID
      redirectUrl: `/websoket?conversationId=${newConversation._id}`
    });

  } catch (error) {
    console.error('创建对话错误:', error);
    res.status(500).json({ error: '服务器错误，创建对话失败' });
  }
});

// routes/api.js
// 添加获取对话总数的接口
router.get('/conversations/count', async (req, res) => {
  try {
    const counter = await Counter.findOne({ name: 'conversation' });
    res.json({ 
      count: counter ? counter.count : 0 
    });
  } catch (error) {
    console.error('获取对话总数错误:', error);
    res.status(500).json({ error: '获取对话总数失败' });
  }
});


module.exports = router;